import express from 'express';
import fs from 'fs';
import path from 'path';
import cors from 'cors';

const app = express();
const PORT = 3001;

// 创建data目录用于存储数据
// 使用process.cwd()获取当前工作目录，更简单可靠
const dataDir = path.join(process.cwd(), 'data');
if (!fs.existsSync(dataDir)) {
  fs.mkdirSync(dataDir, { recursive: true });
}

// 中间件
app.use(cors());
app.use(express.json());

// 数据文件路径
const todosFilePath = path.join(dataDir, 'todos.json');
const taskGroupsFilePath = path.join(dataDir, 'taskGroups.json');
const usersFilePath = path.join(dataDir, 'users.json');

// 用户数据结构
// { username: string, password: string, data: { todos: [], taskGroups: [] } }

// 读取数据文件的辅助函数
function readDataFile(filePath, defaultValue = []) {
  try {
    if (fs.existsSync(filePath)) {
      const data = fs.readFileSync(filePath, 'utf8');
      return JSON.parse(data);
    }
    return defaultValue;
  } catch (error) {
    console.error(`读取文件 ${filePath} 失败:`, error);
    return defaultValue;
  }
}

// 写入数据文件的辅助函数
function writeDataFile(filePath, data) {
  try {
    // 直接保存数据，不添加额外包装
    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
    console.log(`数据已保存到 ${filePath}`);
    return true;
  } catch (error) {
    console.error(`写入文件 ${filePath} 失败:`, error);
    return false;
  }
}

// API 路由

// 用户注册
app.post('/api/register', (req, res) => {
  try {
    const { username, password, guestData } = req.body;
    
    // 读取现有用户数据
    const users = readDataFile(usersFilePath, []);
    
    // 检查用户名是否已存在
    if (users.find(user => user.username === username)) {
      return res.status(400).json({ success: false, message: '用户名已存在' });
    }
    
    // 创建新用户
    const newUser = {
      username,
      password, // 实际应用中应该加密存储
      data: {
        todos: guestData?.todos || [],
        taskGroups: guestData?.taskGroups || [{ id: 'default', name: '默认任务组', createTime: new Date().toISOString() }]
      }
    };
    
    // 保存用户数据
    users.push(newUser);
    writeDataFile(usersFilePath, users);
    
    res.json({ success: true, message: '注册成功' });
  } catch (error) {
    console.error('注册失败:', error);
    res.status(500).json({ success: false, message: '注册失败' });
  }
});

// 用户登录
app.post('/api/login', (req, res) => {
  try {
    const { username, password } = req.body;
    
    // 读取现有用户数据
    const users = readDataFile(usersFilePath, []);
    
    // 查找用户
    const user = users.find(u => u.username === username && u.password === password);
    
    if (user) {
      res.json({ 
        success: true, 
        username: user.username,
        data: user.data
      });
    } else {
      res.status(401).json({ success: false, message: '用户名或密码错误' });
    }
  } catch (error) {
    console.error('登录失败:', error);
    res.status(500).json({ success: false, message: '登录失败' });
  }
});

// 获取用户数据
app.post('/api/userData', (req, res) => {
  try {
    const { username } = req.body;
    
    // 读取现有用户数据
    const users = readDataFile(usersFilePath, []);
    
    // 查找用户
    const user = users.find(u => u.username === username);
    
    if (user) {
      res.json({ 
        success: true, 
        data: user.data
      });
    } else {
      res.status(404).json({ success: false, message: '用户不存在' });
    }
  } catch (error) {
    console.error('获取用户数据失败:', error);
    res.status(500).json({ success: false, message: '获取用户数据失败' });
  }
});

// 保存用户数据
app.post('/api/saveUserData', (req, res) => {
  try {
    const { username, data } = req.body;
    
    // 读取现有用户数据
    const users = readDataFile(usersFilePath, []);
    
    // 查找用户
    const userIndex = users.findIndex(u => u.username === username);
    
    if (userIndex !== -1) {
      // 更新用户数据
      users[userIndex].data = data;
      writeDataFile(usersFilePath, users);
      res.json({ success: true });
    } else {
      res.status(404).json({ success: false, message: '用户不存在' });
    }
  } catch (error) {
    console.error('保存用户数据失败:', error);
    res.status(500).json({ success: false, message: '保存用户数据失败' });
  }
});

// 获取任务数据（兼容旧API，但会被废弃）
app.get('/api/todos', (req, res) => {
  const todos = readDataFile(todosFilePath, []);
  res.json(todos);
});

// 保存任务数据（兼容旧API，但会被废弃）
app.post('/api/todos', (req, res) => {
  const todos = req.body;
  const success = writeDataFile(todosFilePath, todos);
  res.json({ success });
});

// 获取任务组数据（兼容旧API，但会被废弃）
app.get('/api/taskGroups', (req, res) => {
  const taskGroups = readDataFile(taskGroupsFilePath, []);
  res.json(taskGroups);
});

// 保存任务组数据（兼容旧API，但会被废弃）
app.post('/api/taskGroups', (req, res) => {
  const taskGroups = req.body;
  const success = writeDataFile(taskGroupsFilePath, taskGroups);
  res.json({ success });
});

// 清空所有数据
app.delete('/api/allData', (req, res) => {
  try {
    // 清空任务文件
    writeDataFile(todosFilePath, []);
    // 清空任务组文件，但保留默认任务组
    const defaultGroup = {
      id: 'default',
      name: '默认任务组',
      createTime: new Date().toISOString()
    };
    writeDataFile(taskGroupsFilePath, [defaultGroup]);
    res.json({ success: true });
  } catch (error) {
    console.error('清空数据失败:', error);
    res.json({ success: false, error: error.message });
  }
});

// 静态文件服务
app.use(express.static(path.join(process.cwd(), 'dist')));

// 启动服务器
app.listen(PORT, () => {
  console.log(`服务器运行在 http://localhost:${PORT}`);
  console.log(`数据将存储在 ${dataDir} 目录中`);
});